#include "listes.h"

/* FONCTION D'INITIALISATION D'UN JOUEUR */
void initJoueur(Joueur *j, int numero)
{
    j->numero = numero;
    j->jeu = (ListeCartes*) malloc (sizeof(ListeCartes));
    j->jeu->pt_tete = NULL;
    j->pari = 0;
    j->plis = 0;
    j->points = 0;
}

/* FONCTION D'INITIALISATION DU JOUEUR DONNE UNIQUEMENT */
void initDonne(Joueur* donne, int numero)
{
    int compteur = 1;
    donne->numero = numero;
    donne->jeu = (ListeCartes*) malloc (sizeof(ListeCartes));
    donne->jeu->pt_tete = NULL;
    for(compteur = 1; compteur < NBMAX+1 ; compteur++)
    {
        if(compteur)
             initAjoutCarteTete(donne, compteur);
        else
            initAjoutCarteFin(donne, compteur);
    }
}

/* FONCTION PERMETTANT DE VERIFIER SI UNE LISTE EST VIDE OU NON */
int listeVide(ListeCartes jeu)
{
    return(jeu.pt_tete == NULL);
}

/* FONCTION PERMETTANT DE FABRIQUER UNE CARTE EN TETE DE LISTE */
void initAjoutCarteTete(Joueur* donne, int valeur)
{
    Carte* nouvelle = (Carte*) malloc (sizeof(Carte));
    initCarte(nouvelle);
    nouvelle->valeur = valeur;
    if(listeVide(*donne->jeu))
    {
        donne->jeu->pt_tete = nouvelle;
        nouvelle->suiv = NULL;
    }
    else
    {
        nouvelle->suiv = donne->jeu->pt_tete;
        donne->jeu->pt_tete = nouvelle;
    }
}

/* FONCTION PERMETTANT DE FABRIQUER UNE CARTE EN FIN DE LISTE */
void initAjoutCarteFin(Joueur* donne, int valeur)
{
    Carte* nouvelle = (Carte*) malloc (sizeof(Carte));
    Carte* tmp = donne->jeu->pt_tete;
    initCarte(nouvelle);
    nouvelle->valeur = valeur;
    if(!listeVide(*donne->jeu))
    {
        while(tmp->suiv != NULL)
        {
            tmp = tmp->suiv;
        }
        tmp->suiv = nouvelle;
        nouvelle->suiv = NULL;
    }
    else
        initAjoutCarteTete(donne, valeur);
}

/* FONCTION D'AFFICHAGE DE LISTE *** UTILISABLE EN CONSOLE UNIQUEMENT *** */
void affichageListe(Joueur j)
{
    Carte* tmp = j.jeu->pt_tete;
    printf("\n\nCartes en main :\n\n\n");
    if(tmp != NULL)
    {
        while(tmp != NULL)
        {
            printf("| %d\t", tmp->valeur);
            tmp = tmp->suiv;
        }
    }
    else
        printf("Liste vide !\n\n");
}

/* FONCTION PERMETTANT D'AJOUTER UNE CARTE (PREALABLEMENT CREEE) EN DEBUT DE LISTE */
void ajoutCarteTeteListe(Joueur* j, Carte* nouvelle)
{
    if(listeVide(*j->jeu))
    {
        j->jeu->pt_tete = nouvelle;
    }
    else
    {
        nouvelle->suiv = j->jeu->pt_tete;
        j->jeu->pt_tete = nouvelle;
    }
}

/* FONCTION PERMETTANT D'AJOUTER UNE CARTE (PREALABLEMENT CREEE) EN FIN DE LISTE */
void ajoutCarteFinListe(Joueur* j, Carte* nouvelle)
{
    Carte* tmp = j->jeu->pt_tete;
    if(!listeVide(*j->jeu))
    {
        while(tmp->suiv != NULL)
        {
            tmp = tmp->suiv;
        }
        tmp->suiv = nouvelle;
        nouvelle->suiv = NULL;
    }
    else
        ajoutCarteTeteListe(j, nouvelle);
}

/* FONCTION PERMETTANT D'AJOUTER UNE CARTE (PREALABLEMENT CREEE) A N'IMPORTE QUELLE POSITION DE LA LISTE */
void ajoutCarteListe(Joueur* j1, Joueur* j2, int position, int positionmax)
{
    Carte* nouvelle = supprCarteListe(j1, position, positionmax);
    nouvelle->suiv = NULL;
    if(!listeVide(*j2->jeu))
    {
        if(nouvelle->valeur > j2->jeu->pt_tete->valeur)
        {
            nouvelle->suiv = j2->jeu->pt_tete;
            j2->jeu->pt_tete = nouvelle;
        }
        else
        {
            Carte* tmp = j2->jeu->pt_tete;
            while(tmp->suiv!= NULL && nouvelle->valeur < tmp->suiv->valeur)
            {
                tmp = tmp->suiv;
            }
            if(tmp->suiv != NULL)
            {
                nouvelle->suiv = tmp->suiv;
                tmp->suiv = nouvelle;
            }
            else
            {
                if(nouvelle->valeur > tmp->valeur)
                    ajoutCarteTeteListe(j2, nouvelle);
                else
                    ajoutCarteFinListe(j2, nouvelle);
            }
        }
    }
    else
        ajoutCarteTeteListe(j2, nouvelle);
}

/* FONCTION PERMETTANT DE SUPPRIMER UNE CARTE (PREALABLEMENT CREEE) EN DEBUT DE LISTE */
Carte* supprCarteTeteListe(Joueur* j)
{
    Carte* tmp = j->jeu->pt_tete;
    if(!listeVide(*j->jeu))
    {
        if(tmp->suiv == NULL)
        {
            j->jeu->pt_tete = NULL;
            tmp->suiv = NULL;
            return(tmp);
        }
        else
        {
            j->jeu->pt_tete = tmp->suiv;
            tmp->suiv = NULL;
            return(tmp);
        }
    }
    return(NULL);
}

/* FONCTION PERMETTANT DE SUPPRIMER UNE CARTE (PREALABLEMENT CREEE) EN FIN DE LISTE */
Carte* supprCarteFinListe(Joueur* j)
{
    Carte* tmp = j->jeu->pt_tete;
    Carte* tmp2 = NULL;
    if(!listeVide(*j->jeu))
    {
        if(tmp->suiv != NULL)
        {
            while(tmp->suiv != NULL)
            {
                tmp2 = tmp;
                tmp = tmp->suiv;
            }
            tmp2->suiv = NULL;
            return(tmp);
        }
        else
            return(supprCarteTeteListe(j));
    }
    return(NULL);
}

/*** FONCTION A CORRIGER ***/
/* FONCTION PERMETTANT DE SUPPRIMER UNE CARTE (PREALABLEMENT CREEE) A N'IMPORTE QUELLE POSITION DE LA LISTE */
Carte* supprCarteListe(Joueur* j, int position, int positionmax)
{
    if(!listeVide(*j->jeu))
    {
        if(position > 1 && position < positionmax)
        {
            Carte* tmp = j->jeu->pt_tete;
            Carte* tmp2 = j->jeu->pt_tete->suiv;
            int compteur;
            for(compteur = 1 ; compteur < position - 1 ; compteur++)
            {
                tmp = tmp->suiv;
                tmp2 = tmp2->suiv;
            }
            //tmp->suiv = tmp2->suiv;
            //tmp2 = tmp->suiv;
            tmp->suiv = tmp->suiv->suiv;
            tmp2->suiv = NULL;
            //free(tmp);
            //tmp->suiv = NULL;
            return(tmp2);
        }
        if(position == 1)
            return(supprCarteTeteListe(j));
        if(position == positionmax)
            return(supprCarteFinListe(j));
    }
    return(NULL);
}
/*** ***/

/* FONCTION PERMETTANT DE MELANGER LA DONNE DE MANIERE PSEUDO-ALEATOIRE */
void melangeDonne(Joueur* donne)
{
    int compteur, compteurA, compteurB;
	int tirage = 0;
	Carte* tmp = (Carte*) malloc (sizeof(Carte));
	initCarte(tmp);
	for(compteur = 1; compteur < NBMAX+1; compteur++)
	{
	    compteurA = 1;
	    compteurB = 1;
        tirage = nbAleatoire();
        Carte* carteA = donne->jeu->pt_tete;
        Carte* carteB = donne->jeu->pt_tete;
        while(compteurA < compteur)
        {
            carteA = carteA->suiv;
            compteurA++;
        }
        while(compteurB < tirage)
        {
            carteB = carteB->suiv;
            compteurB++;
        }
        tmp->valeur = carteA->valeur;
        carteA->valeur = carteB->valeur;
        carteB->valeur = tmp->valeur;
        free(tmp);
	}
}

/* FONCTION DE DISTRIBUTION DES CARTES A TOUS LES JOUEURS */
void distributionListe(Joueur* j1, Joueur* j2, Joueur* j3, Joueur* j4, Joueur* chien, Joueur* donne)
{
    int compteur, compteur2 = 0, tirage, positionmax = 23;
    for(compteur = 0 ; compteur < 5 ; compteur++)
    {
        ajoutCarteListe(donne, j1, 1, positionmax);
        ajoutCarteListe(donne, j2, 1, positionmax);
        ajoutCarteListe(donne, j3, 1, positionmax);
        ajoutCarteListe(donne, j4, 1, positionmax);
        positionmax = positionmax - 4;
        if(compteur2 < 2)
        {
            tirage = positionmax;
            while(tirage > positionmax)
                tirage = nbAleatoire();

            ajoutCarteListe(donne, chien, tirage, positionmax);

            compteur2++;
        }
        positionmax--;
    }
}
